/*
*Description:
*User:laoHu
*Created with Intellij IDEA 2025
*Data:2025.05.29
*Time:14:56
*/

import Demo2.Cat;
import Demo2.Dog;
import Demo4.Derived;
import Demo5.Person;
import Demo6.Student;
import Demo7.Banz;
import Demo7.Car;
import java.util.Scanner;

//为什么构造方法不能被子类继承？

//这是由于构造器的特殊规定决定的，构造器的定义和普通方法相比：
//
//构造器不需要返回类型
//构造器和类名相同
//假如构造器被子类继承，其具备的地位有两种可能：
//
//一是作为子类的构造器
//二是作为子类对象的普通方法
//但是，如果作为子类的构造方法（构造器），其和子类名不一致，违背了构造方法的规定；
//作为子类对象的普通方法，则其没有返回值，违背了普通方法的规定。
//
//综上，构造器不能被子类继承。

public class Test {

    //练习2
            public  void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                while (scanner.hasNextInt()) {
                    int x = scanner.nextInt();
                    int y = scanner.nextInt();
                    Sub sub = new Sub(x, y);
                    sub.calculate();
                }
            }

        class Base {

            private int x;
            private int y;

            public Base(int x, int y) {
                this.x = x;
                this.y = y;
            }

            public int getX() {
                return x;
            }

            public int getY() {
                return y;
            }

            public void calculate() {
                int z = getY();
                if(z == 0){
                    System.out.printf("Error");
                } else{

                    System.out.println(getX() / getY());
                }
            }
        }

        class Sub extends Base {

            public Sub(int x ,int y){
                super(x,y);
            }
        }

    //练习1
        public  void main9(String[] args) {
            Scanner scanner = new Scanner(System.in);
            while (true) {
                int x = scanner.nextInt();
                int y = scanner.nextInt();
                int z = scanner.nextInt();
                Sub1 sub = new Sub1(x, y, z);
                System.out.println(sub.calculate());
            }
        }

    }

    class Base {

        private int x;
        private int y;

        public Base(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public int getX() {
            return x;
        }

        public int getY() {
            return y;
        }

    }

    class Sub1 extends Base {

        private int z;

        public Sub1(int x, int y, int z) {

            super(x,y);
            this.z = z;
        }

        public int getZ() {
            return z;
        }

        public int calculate() {
            return super.getX() * super.getY() * this.getZ();
        }


    //组合
    public static void main8(String[] args) {
        //可以实例化多个对象
        Banz banz = new Banz();
    }

    //不可继承的类
//    final public class sta{
//        static int x;
//        static int y;
//    }

    //报错，被final修饰的类不可被继承
//    public class sta2 extends sta{
//
//    }

    //final修饰的的变量或者字段（String)
    public static void main7(String[] args) {
        final int a =  10;
        //a = 1;//报错，因为a此时已近被定义为常量
        //a = 1等价于 10 = 1,会报错
      // String 就是被final修饰的字段
    }

    //protect修饰的成员变量：可以在同一个包使用
    //如果在不同包中使用需要通过继承，在子类中使用
    public static void main6(String[] args) {

        Student student = new Student();
       //System.out.println(student.age);报错，Test不是Person的子类
    }


    //继承中代码块的执行顺序
    public static void main5(String[] args) {
        //实例化对象
        Student student = new Student();
        //静态代码块最先执行，先执行父类后执行字符
        //执行父类的实例化代码块后构造方法代码块
        //后执行子类的实例化代码块和构造方法代码块
        Student student1 = new Student();
        //静态代码块只执行一次
    }


    //父类和子类发构造
    public static void main4(String[] args) {

        Derived derived = new Derived();

    }

    //super关键字调用父类方法和成员变量
    public static void main3(String[] args) {
        Derived derived = new Derived();
        derived.method();
        derived.methodD();
        derived.methodC();
        derived.print();
    }

    //使用父类的方法
    public static void main2(String[] args) {

        Derived derived = new Derived();

        System.out.println(derived.a);
        derived.method();
        derived.methodC();
    }

    //继承的使用
    public static void main1(String[] args) {
        //创建对象
        Dog dog = new Dog();
        Cat cat = new Cat();

        //使用对象
        cat.setAge(2);
        dog.name = "wanCai";
         dog.setAge(3);
        cat.name = "huaHua";

        //父类继承的方法
        dog.printAge();
        dog.bark();
        cat.printAge();
        cat.sleep();

    }

}

